/*
 * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 */
package im.composer.media.sound.synth;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.AudioFormat.Encoding;
import javax.sound.sampled.spi.FormatConversionProvider;

/**
 * This class is used to convert between 8,16,24,32 bit signed/unsigned
 * big/litle endian fixed/floating stereo/mono/multi-channel audio streams and
 * perform sample-rate conversion if needed.
 * 
 * @author Karl Helgason
 */
public class AudioFloatFormatConverter extends FormatConversionProvider {

	private static class AudioFloatFormatConverterInputStream extends InputStream {
		private AudioFloatConverter converter;

		private AudioFloatInputStream stream;

		private float[] readfloatbuffer;

		private int fsize = 0;

		public AudioFloatFormatConverterInputStream(AudioFormat targetFormat, AudioFloatInputStream stream) {
			this.stream = stream;
			converter = AudioFloatConverter.getConverter(targetFormat);
			fsize = ((targetFormat.getSampleSizeInBits() + 7) / 8);
		}

		public int read() throws IOException {
			byte[] b = new byte[1];
			int ret = read(b);
			if (ret < 0)
				return ret;
			return b[0] & 0xFF;
		}

		public int read(byte[] b, int off, int len) throws IOException {

			int flen = len / fsize;
			if (readfloatbuffer == null || readfloatbuffer.length < flen)
				readfloatbuffer = new float[flen];
			int ret = stream.read(readfloatbuffer, 0, flen);
			if (ret < 0)
				return ret;
			converter.toByteArray(readfloatbuffer, 0, ret, b, off);
			return ret * fsize;
		}

		public int available() throws IOException {
			int ret = stream.available();
			if (ret < 0)
				return ret;
			return ret * fsize;
		}

		public void close() throws IOException {
			stream.close();
		}

		public synchronized void mark(int readlimit) {
			stream.mark(readlimit * fsize);
		}

		public boolean markSupported() {
			return stream.markSupported();
		}

		public synchronized void reset() throws IOException {
			stream.reset();
		}

		public long skip(long n) throws IOException {
			long ret = stream.skip(n / fsize);
			if (ret < 0)
				return ret;
			return ret * fsize;
		}

	}

	private static class AudioFloatInputStreamChannelMixer extends AudioFloatInputStream {

		private int targetChannels;

		private int sourceChannels;

		private AudioFloatInputStream ais;

		private AudioFormat targetFormat;

		private float[] conversion_buffer;

		public AudioFloatInputStreamChannelMixer(AudioFloatInputStream ais, int targetChannels) {
			this.sourceChannels = ais.getFormat().getChannels();
			this.targetChannels = targetChannels;
			this.ais = ais;
			AudioFormat format = ais.getFormat();
			targetFormat = new AudioFormat(format.getEncoding(), format.getSampleRate(), format.getSampleSizeInBits(), targetChannels, (format.getFrameSize() / sourceChannels) * targetChannels,
					format.getFrameRate(), format.isBigEndian());
		}

		public int available() throws IOException {
			return (ais.available() / sourceChannels) * targetChannels;
		}

		public void close() throws IOException {
			ais.close();
		}

		public AudioFormat getFormat() {
			return targetFormat;
		}

		public long getFrameLength() {
			return ais.getFrameLength();
		}

		public void mark(int readlimit) {
			ais.mark((readlimit / targetChannels) * sourceChannels);
		}

		public boolean markSupported() {
			return ais.markSupported();
		}

		public int read(float[] b, int off, int len) throws IOException {
			int len2 = (len / targetChannels) * sourceChannels;
			if (conversion_buffer == null || conversion_buffer.length < len2)
				conversion_buffer = new float[len2];
			int ret = ais.read(conversion_buffer, 0, len2);
			if (ret < 0)
				return ret;
			if (sourceChannels == 1) {
				int cs = targetChannels;
				for (int c = 0; c < targetChannels; c++) {
					for (int i = 0, ix = off + c; i < len2; i++, ix += cs) {
						b[ix] = conversion_buffer[i];
					}
				}
			} else if (targetChannels == 1) {
				int cs = sourceChannels;
				for (int i = 0, ix = off; i < len2; i += cs, ix++) {
					b[ix] = conversion_buffer[i];
				}
				for (int c = 1; c < sourceChannels; c++) {
					for (int i = c, ix = off; i < len2; i += cs, ix++) {
						b[ix] += conversion_buffer[i];
					}
				}
				float vol = 1f / ((float) sourceChannels);
				for (int i = 0, ix = off; i < len2; i += cs, ix++) {
					b[ix] *= vol;
				}
			} else {
				int minChannels = Math.min(sourceChannels, targetChannels);
				int off_len = off + len;
				int ct = targetChannels;
				int cs = sourceChannels;
				for (int c = 0; c < minChannels; c++) {
					for (int i = off + c, ix = c; i < off_len; i += ct, ix += cs) {
						b[i] = conversion_buffer[ix];
					}
				}
				for (int c = minChannels; c < targetChannels; c++) {
					for (int i = off + c; i < off_len; i += ct) {
						b[i] = 0;
					}
				}
			}
			return (ret / sourceChannels) * targetChannels;
		}

		public void reset() throws IOException {
			ais.reset();
		}

		public long skip(long len) throws IOException {
			long ret = ais.skip((len / targetChannels) * sourceChannels);
			if (ret < 0)
				return ret;
			return (ret / sourceChannels) * targetChannels;
		}

	}

	private static class AudioFloatInputStreamResampler extends AudioFloatInputStream {

		private AudioFloatInputStream ais;

		private AudioFormat targetFormat;

		private float[] skipbuffer;

		private SoftAbstractResampler resampler;

		private float[] pitch = new float[1];

		private float[] ibuffer2;

		private float[][] ibuffer;

		private float ibuffer_index = 0;

		private int ibuffer_len = 0;

		private int nrofchannels = 0;

		private float[][] cbuffer;

		private int buffer_len = 512;

		private int pad;

		private int pad2;

		private float[] ix = new float[1];

		private int[] ox = new int[1];

		private float[][] mark_ibuffer = null;

		private float mark_ibuffer_index = 0;

		private int mark_ibuffer_len = 0;

		public AudioFloatInputStreamResampler(AudioFloatInputStream ais, AudioFormat format) {
			this.ais = ais;
			AudioFormat sourceFormat = ais.getFormat();
			targetFormat = new AudioFormat(sourceFormat.getEncoding(), format.getSampleRate(), sourceFormat.getSampleSizeInBits(), sourceFormat.getChannels(), sourceFormat.getFrameSize(),
					format.getSampleRate(), sourceFormat.isBigEndian());
			nrofchannels = targetFormat.getChannels();
			Object interpolation = format.getProperty("interpolation");
			if (interpolation != null && (interpolation instanceof String)) {
				String resamplerType = (String) interpolation;
				if (resamplerType.equalsIgnoreCase("point"))
					this.resampler = new SoftPointResampler();
				if (resamplerType.equalsIgnoreCase("linear"))
					this.resampler = new SoftLinearResampler2();
				if (resamplerType.equalsIgnoreCase("linear1"))
					this.resampler = new SoftLinearResampler();
				if (resamplerType.equalsIgnoreCase("linear2"))
					this.resampler = new SoftLinearResampler2();
				if (resamplerType.equalsIgnoreCase("cubic"))
					this.resampler = new SoftCubicResampler();
				if (resamplerType.equalsIgnoreCase("lanczos"))
					this.resampler = new SoftLanczosResampler();
				if (resamplerType.equalsIgnoreCase("sinc"))
					this.resampler = new SoftSincResampler();
			}
			if (resampler == null)
				resampler = new SoftLinearResampler2(); // new
														// SoftLinearResampler2();
			pitch[0] = sourceFormat.getSampleRate() / format.getSampleRate();
			pad = resampler.getPadding();
			pad2 = pad * 2;
			ibuffer = new float[nrofchannels][buffer_len + pad2];
			ibuffer2 = new float[nrofchannels * buffer_len];
			ibuffer_index = buffer_len + pad;
			ibuffer_len = buffer_len;
		}

		public int available() throws IOException {
			return 0;
		}

		public void close() throws IOException {
			ais.close();
		}

		public AudioFormat getFormat() {
			return targetFormat;
		}

		public long getFrameLength() {
			return AudioSystem.NOT_SPECIFIED; // ais.getFrameLength();
		}

		public void mark(int readlimit) {
			ais.mark((int) (readlimit * pitch[0]));
			mark_ibuffer_index = ibuffer_index;
			mark_ibuffer_len = ibuffer_len;
			if (mark_ibuffer == null) {
				mark_ibuffer = new float[ibuffer.length][ibuffer[0].length];
			}
			for (int c = 0; c < ibuffer.length; c++) {
				float[] from = ibuffer[c];
				float[] to = mark_ibuffer[c];
				for (int i = 0; i < to.length; i++) {
					to[i] = from[i];
				}
			}
		}

		public boolean markSupported() {
			return ais.markSupported();
		}

		private void readNextBuffer() throws IOException {

			if (ibuffer_len == -1)
				return;

			for (int c = 0; c < nrofchannels; c++) {
				float[] buff = ibuffer[c];
				int buffer_len_pad = ibuffer_len + pad2;
				for (int i = ibuffer_len, ix = 0; i < buffer_len_pad; i++, ix++) {
					buff[ix] = buff[i];
				}
			}

			ibuffer_index -= (ibuffer_len);

			ibuffer_len = ais.read(ibuffer2);
			if (ibuffer_len >= 0) {
				while (ibuffer_len < ibuffer2.length) {
					int ret = ais.read(ibuffer2, ibuffer_len, ibuffer2.length - ibuffer_len);
					if (ret == -1)
						break;
					ibuffer_len += ret;
				}
				Arrays.fill(ibuffer2, ibuffer_len, ibuffer2.length, 0);
				ibuffer_len /= nrofchannels;
			} else {
				Arrays.fill(ibuffer2, 0, ibuffer2.length, 0);
			}

			int ibuffer2_len = ibuffer2.length;
			for (int c = 0; c < nrofchannels; c++) {
				float[] buff = ibuffer[c];
				for (int i = c, ix = pad2; i < ibuffer2_len; i += nrofchannels, ix++) {
					buff[ix] = ibuffer2[i];
				}
			}

		}

		public int read(float[] b, int off, int len) throws IOException {

			if (cbuffer == null || cbuffer[0].length < len / nrofchannels) {
				cbuffer = new float[nrofchannels][len / nrofchannels];
			}
			if (ibuffer_len == -1)
				return -1;
			if (len < 0)
				return 0;
			int offlen = off + len;
			int remain = len / nrofchannels;
			int destPos = 0;
			int in_end = ibuffer_len;
			while (remain > 0) {
				if (ibuffer_len >= 0) {
					if (ibuffer_index >= (ibuffer_len + pad))
						readNextBuffer();
					in_end = ibuffer_len + pad;
				}

				if (ibuffer_len < 0) {
					in_end = pad2;
					if (ibuffer_index >= in_end)
						break;
				}

				if (ibuffer_index < 0)
					break;
				int preDestPos = destPos;
				for (int c = 0; c < nrofchannels; c++) {
					ix[0] = ibuffer_index;
					ox[0] = destPos;
					float[] buff = ibuffer[c];
					resampler.interpolate(buff, ix, in_end, pitch, 0, cbuffer[c], ox, len / nrofchannels);
				}
				ibuffer_index = ix[0];
				destPos = ox[0];
				remain -= destPos - preDestPos;
			}
			for (int c = 0; c < nrofchannels; c++) {
				int ix = 0;
				float[] buff = cbuffer[c];
				for (int i = c + off; i < offlen; i += nrofchannels) {
					b[i] = buff[ix++];
				}
			}
			return len - remain * nrofchannels;
		}

		public void reset() throws IOException {
			ais.reset();
			if (mark_ibuffer == null)
				return;
			ibuffer_index = mark_ibuffer_index;
			ibuffer_len = mark_ibuffer_len;
			for (int c = 0; c < ibuffer.length; c++) {
				float[] from = mark_ibuffer[c];
				float[] to = ibuffer[c];
				for (int i = 0; i < to.length; i++) {
					to[i] = from[i];
				}
			}

		}

		public long skip(long len) throws IOException {
			if (len < 0)
				return 0;
			if (skipbuffer == null)
				skipbuffer = new float[1024 * targetFormat.getFrameSize()];
			float[] l_skipbuffer = skipbuffer;
			long remain = len;
			while (remain > 0) {
				int ret = read(l_skipbuffer, 0, (int) Math.min(remain, skipbuffer.length));
				if (ret < 0) {
					if (remain == len)
						return ret;
					break;
				}
				remain -= ret;
			}
			return len - remain;

		}

	}

	private Encoding[] formats = { Encoding.PCM_SIGNED, Encoding.PCM_UNSIGNED, AudioFloatConverter.PCM_FLOAT };

	public AudioInputStream getAudioInputStream(Encoding targetEncoding, AudioInputStream sourceStream) {
		if (sourceStream.getFormat().getEncoding().equals(targetEncoding))
			return sourceStream;
		AudioFormat format = sourceStream.getFormat();
		int channels = format.getChannels();
		Encoding encoding = targetEncoding;
		float samplerate = format.getSampleRate();
		int bits = format.getSampleSizeInBits();
		boolean bigendian = format.isBigEndian();
		if (targetEncoding.equals(AudioFloatConverter.PCM_FLOAT))
			bits = 32;
		AudioFormat targetFormat = new AudioFormat(encoding, samplerate, bits, channels, channels * bits / 8, samplerate, bigendian);
		return getAudioInputStream(targetFormat, sourceStream);
	}

	public AudioInputStream getAudioInputStream(AudioFormat targetFormat, AudioInputStream sourceStream) {
		if (!isConversionSupported(targetFormat, sourceStream.getFormat()))
			throw new IllegalArgumentException("Unsupported conversion: " + sourceStream.getFormat().toString() + " to " + targetFormat.toString());
		return getAudioInputStream(targetFormat, AudioFloatInputStream.getInputStream(sourceStream));
	}

	public AudioInputStream getAudioInputStream(AudioFormat targetFormat, AudioFloatInputStream sourceStream) {

		if (!isConversionSupported(targetFormat, sourceStream.getFormat()))
			throw new IllegalArgumentException("Unsupported conversion: " + sourceStream.getFormat().toString() + " to " + targetFormat.toString());
		if (targetFormat.getChannels() != sourceStream.getFormat().getChannels())
			sourceStream = new AudioFloatInputStreamChannelMixer(sourceStream, targetFormat.getChannels());
		if (Math.abs(targetFormat.getSampleRate() - sourceStream.getFormat().getSampleRate()) > 0.000001)
			sourceStream = new AudioFloatInputStreamResampler(sourceStream, targetFormat);
		return new AudioInputStream(new AudioFloatFormatConverterInputStream(targetFormat, sourceStream), targetFormat, sourceStream.getFrameLength());
	}

	public Encoding[] getSourceEncodings() {
		return new Encoding[] { Encoding.PCM_SIGNED, Encoding.PCM_UNSIGNED, AudioFloatConverter.PCM_FLOAT };
	}

	public Encoding[] getTargetEncodings() {
		return new Encoding[] { Encoding.PCM_SIGNED, Encoding.PCM_UNSIGNED, AudioFloatConverter.PCM_FLOAT };
	}

	public Encoding[] getTargetEncodings(AudioFormat sourceFormat) {
		if (AudioFloatConverter.getConverter(sourceFormat) == null)
			return new Encoding[0];
		return new Encoding[] { Encoding.PCM_SIGNED, Encoding.PCM_UNSIGNED, AudioFloatConverter.PCM_FLOAT };
	}

	public AudioFormat[] getTargetFormats(Encoding targetEncoding, AudioFormat sourceFormat) {
		if (AudioFloatConverter.getConverter(sourceFormat) == null)
			return new AudioFormat[0];
		int channels = sourceFormat.getChannels();

		ArrayList<AudioFormat> formats = new ArrayList<AudioFormat>();

		if (targetEncoding.equals(Encoding.PCM_SIGNED))
			formats.add(new AudioFormat(Encoding.PCM_SIGNED, AudioSystem.NOT_SPECIFIED, 8, channels, channels, AudioSystem.NOT_SPECIFIED, false));
		if (targetEncoding.equals(Encoding.PCM_UNSIGNED))
			formats.add(new AudioFormat(Encoding.PCM_UNSIGNED, AudioSystem.NOT_SPECIFIED, 8, channels, channels, AudioSystem.NOT_SPECIFIED, false));

		for (int bits = 16; bits < 32; bits += 8) {
			if (targetEncoding.equals(Encoding.PCM_SIGNED)) {
				formats.add(new AudioFormat(Encoding.PCM_SIGNED, AudioSystem.NOT_SPECIFIED, bits, channels, channels * bits / 8, AudioSystem.NOT_SPECIFIED, false));
				formats.add(new AudioFormat(Encoding.PCM_SIGNED, AudioSystem.NOT_SPECIFIED, bits, channels, channels * bits / 8, AudioSystem.NOT_SPECIFIED, true));
			}
			if (targetEncoding.equals(Encoding.PCM_UNSIGNED)) {
				formats.add(new AudioFormat(Encoding.PCM_UNSIGNED, AudioSystem.NOT_SPECIFIED, bits, channels, channels * bits / 8, AudioSystem.NOT_SPECIFIED, true));
				formats.add(new AudioFormat(Encoding.PCM_UNSIGNED, AudioSystem.NOT_SPECIFIED, bits, channels, channels * bits / 8, AudioSystem.NOT_SPECIFIED, false));
			}
		}

		if (targetEncoding.equals(AudioFloatConverter.PCM_FLOAT)) {
			formats.add(new AudioFormat(AudioFloatConverter.PCM_FLOAT, AudioSystem.NOT_SPECIFIED, 32, channels, channels * 4, AudioSystem.NOT_SPECIFIED, false));
			formats.add(new AudioFormat(AudioFloatConverter.PCM_FLOAT, AudioSystem.NOT_SPECIFIED, 32, channels, channels * 4, AudioSystem.NOT_SPECIFIED, true));
			formats.add(new AudioFormat(AudioFloatConverter.PCM_FLOAT, AudioSystem.NOT_SPECIFIED, 64, channels, channels * 8, AudioSystem.NOT_SPECIFIED, false));
			formats.add(new AudioFormat(AudioFloatConverter.PCM_FLOAT, AudioSystem.NOT_SPECIFIED, 64, channels, channels * 8, AudioSystem.NOT_SPECIFIED, true));
		}

		return formats.toArray(new AudioFormat[formats.size()]);
	}

	public boolean isConversionSupported(AudioFormat targetFormat, AudioFormat sourceFormat) {
		if (AudioFloatConverter.getConverter(sourceFormat) == null)
			return false;
		if (AudioFloatConverter.getConverter(targetFormat) == null)
			return false;
		if (sourceFormat.getChannels() <= 0)
			return false;
		if (targetFormat.getChannels() <= 0)
			return false;
		return true;
	}

	public boolean isConversionSupported(Encoding targetEncoding, AudioFormat sourceFormat) {
		if (AudioFloatConverter.getConverter(sourceFormat) == null)
			return false;
		for (int i = 0; i < formats.length; i++) {
			if (targetEncoding.equals(formats[i]))
				return true;
		}
		return false;
	}

}
